/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package LogicaNegocio.Validacion;

import LogicaNegocio.Empleados.Empleado;

/**
 * Esta clase en java permite validar datos y atributos correspondientes
 * a los empleados del sistema BiblioSoft.
 *
 * @author sebaxtian
 * Archivo: VEmpleado.java
 * @version 1.0
 * Fecha: mié abr 21 12:14:16 COT 2010
 */



public class VEmpleado extends Exception {

    //Atributos de clase
    private Empleado objEmpleado;

    /**
     * Metodo constructor que inicializa los atributos
     * a nulos.
     */
    public VEmpleado() {
        this.objEmpleado = null;
    }

    /**
     * Crea un objeto validador de empleado que inicializa
     * los atributos a nulos.
     * Como parametro recibe el mensaje de la excepcion.
     *
     * @param mensajeExcepcion
     */
    public VEmpleado(String mensajeExcepcion) {
        super(mensajeExcepcion);
        this.objEmpleado = null;
    }

    /**
     * Crea un objeto validador de empleado que inicializa
     * los atributos a el objeto que recibe como argumento.
     *
     * @param objEmpleado
     * @throws VEmpleado
     */
    public VEmpleado(Empleado objEmpleado) throws VEmpleado {
        super("Validador de Empleado");
        this.objEmpleado = objEmpleado;
        this.validarIdentificacion(objEmpleado.getCedula());
        this.validarPrimerNombre(objEmpleado.getPrimerNombre());
        this.validarPrimerApellido(objEmpleado.getPrimerApellido());
        this.validarSegundoNombre(objEmpleado.getSegundoNombre());
        this.validarSegundoApellido(objEmpleado.getSegundoApellido());
        this.validarDireccion(objEmpleado.getDireccion());
        this.validarTelefono(objEmpleado.getTelefono());
        this.validarUniversidad(objEmpleado.getUniversidad());
    }

    /**
     * Obtiene el empleado que se ingresa como argumento en el constructor.
     *
     * @return objEmpleado
     */
    public Empleado getEmpleado() {
        return objEmpleado;
    }

    /**
     * Este metodo valida la identificacion del empleado,
     * la longitud minima permitida es de 5 digitos y la
     * logintud maxima permitida es de 10 digitos.
     *
     * @param identificacion
     * @throws VEmpleado
     */
    public void validarIdentificacion(int identificacion) throws VEmpleado {
        String copia = Integer.toString(identificacion);
        if(!copia.matches("[1-9][0-9][0-9]{3,8}")){
            throw new VEmpleado("Formato de identificacion : "+identificacion+" : no valido,\n" +
                    "longitud minima permitida es de 5 digitos,\n" +
                    "logintud maxima permitida es de 10 digitos");
        }
    }

    /**
     * Este metodo valida el primer apellido del empleado,
     * la longitud minima permitida es de 3 caracteres y la
     * logintud maxima permitida es de 59 caracteres.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param primerApellido
     * @throws VEmpleado
     */
    public void validarPrimerApellido(String primerApellido) throws VEmpleado {
        if(primerApellido == null || !primerApellido.matches("[a-zñA-ZÑ]{3,59}")){
            throw new VEmpleado("Formato de primer apellido : "+primerApellido+" : no valido,\n" +
                    "la longitud minima permitida es de 3 caracteres,\n" +
                    "logintud maxima permitida es de 59 caracteres.\n" +
                    "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
        }
    }


    /**
     * Este metodo valida el segundo apellido del empleado,
     * la longitud minima permitida es de 3 caracteres y la
     * logintud maxima permitida es de 59 caracteres.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param segundoApellido
     * @throws VEmpleado
     */
    public void validarSegundoApellido(String segundoApellido) throws VEmpleado {
        if(segundoApellido != null && !segundoApellido.equals("")){
            if(!segundoApellido.matches("[a-zñA-ZÑ]{3,59}")){
                throw new VEmpleado("Formato de segundo apellido : "+segundoApellido+" : no valido,\n" +
                        "la longitud minima permitida es de 3 caracteres,\n" +
                        "logintud maxima permitida es de 59 caracteres.\n" +
                        "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
            }
        }
    }

    /**
     * Este metodo valida el primer nombre del empleado,
     * la longitud minima permitida es de 3 caracteres y la
     * logintud maxima permitida es de 59 caracteres.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param primerNombre
     * @throws VEmpleado
     */
    public void validarPrimerNombre(String primerNombre) throws VEmpleado {
        if(primerNombre == null || !primerNombre.matches("[a-zñA-ZÑ]{3,59}")){
            throw new VEmpleado("Formato de primer nombre : "+primerNombre+" : no valido,\n" +
                    "la longitud minima permitida es de 3 caracteres,\n" +
                    "logintud maxima permitida es de 59 caracteres.\n" +
                    "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
        }
    }

    /**
     * Este metodo valida el segundo nombre del empleado,
     * la longitud minima permitida es de 3 caracteres y la
     * logintud maxima permitida es de 59 caracteres.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param segundoNombre
     * @throws VEmpleado
     */
    public void validarSegundoNombre(String segundoNombre) throws VEmpleado {
        if(segundoNombre != null && !segundoNombre.equals("")){
            if(!segundoNombre.matches("[a-zñA-ZÑ]{3,59}")){
                throw new VEmpleado("Formato de segundo nombre : "+segundoNombre+" : no valido,\n" +
                        "la longitud minima permitida es de 3 caracteres,\n" +
                        "logintud maxima permitida es de 59 caracteres.\n" +
                        "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
            }
        }
    }

    /**
     * Este metodo valida el formato para las direcciones,
     * las direcciones solo pueden tener el siguente formato:
     *
     * cadena numero+caracter # numero - numero
     *
     * Ejemplos:
     * cra 5 # 12 - 23
     * Calle 6A # 6 - 32
     * Diagonal 23 # 12 - 56
     * cra 12A # 8 - 21
     *
     *
     * @param direccion
     * @throws VEmpleado
     */
    public void validarDireccion(String direccion) throws VEmpleado {
        if(direccion == null && direccion.length() < 20){
            throw new VEmpleado("Formato de direccion : "+direccion+" : no valida,\n" +
                    "el formato de direccion debe ser:\n" +
                    "cadena numero+caracter # numero - numero\n" +
                    "La direccion debe contener maximo 20 caracteres\n" +
                    "Ejemplo:\n" +
                    "cra 5 # 12 - 23\n" +
                    "Calle 6A # 6 - 32");
        }
    }

    /**
     * Este metodo valida el numero de telefono.
     * el numero de telefono es un numero de celular
     * ó telefono fijo.
     *
     * @param telefono
     * @throws VEmpleado
     */
    public void validarTelefono(String telefono) throws VEmpleado {
        if(telefono == null || !telefono.matches("[1-9][0-9]{6,9}")){
            throw new VEmpleado("Formato de telefono : "+telefono+" : no valido,\n" +
                    "el numero de telefono es un numero celular ó" +
                    "telefono fijo.\n" +
                    "El numero debe contener como minimo 7 digitos,\n" +
                    "como maximo 10 digitos");
        }
    }

    /**
     * Este metodo valida el formato para la universidad
     * solo se permiten caracteres alfabeticos con longitud minima
     * de 3 caracteres y longitud maxima de 59 caracteres.
     *
     * @param universidad
     * @throws VEmpleado
     */
    public void validarUniversidad(String universidad) throws VEmpleado {
        if(universidad == null || !universidad.matches("[a-zñ A-ZÑ]{3,59}")){
            throw new VEmpleado("Formato de universidad : "+universidad+" : no valido,\n" +
                    "solo se permiten caracteres alfabeticos con longitud minima\n" +
                    "de 3 caracteres y longitud maxima de 30 caracteres.");
        }
    }

    /**
     * Este metodo valida el formato para el password,
     * solo se permiten caracteres alfabeticos en minuscula
     * y numeros enteros, la longitud minima es 8 y la longitud
     * maxima es de 14 caracteres.
     *
     * @param password
     * @throws VEmpleado
     */
    public void validarPassword(String password) throws VEmpleado {
        if(!password.matches("[a-z0-9]{8,14}")){
            throw new VEmpleado("Formato de password : "+password+" no valido,\n" +
                    "solo se permiten caracteres alfabeticos en minuscula\n" +
                    "y numeros enteros, la longitud minima es 8 y la longitud\n" +
                    "maxima es de 14 caracteres.");
        }
    }
}
